home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / bash_114.zip / bash-1.14.2 / jobs.c < prev    next >
C/C++ Source or Header  |  1994-08-11  |  67KB  |  2,694 lines
  1. /* The thing that makes children, remembers them, and contains wait loops. */
  2.  
  3. /* This file works with both POSIX and BSD systems. */
  4.  
  5. /* Copyright (C) 1989, 1992 Free Software Foundation, Inc.
  6.  
  7.    This file is part of GNU Bash, the Bourne Again SHell.
  8.  
  9.    Bash is free software; you can redistribute it and/or modify it under
  10.    the terms of the GNU General Public License as published by the Free
  11.    Software Foundation; either version 1, or (at your option) any later
  12.    version.
  13.  
  14.    Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  15.    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16.    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17.    for more details.
  18.  
  19.    You should have received a copy of the GNU General Public License along
  20.    with Bash; see the file COPYING.  If not, write to the Free Software
  21.    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  22.  
  23. /* Something that can be ignored. */
  24. #define IGNORE_ARG (char *)0
  25.  
  26. #include "config.h"
  27.  
  28. #if !defined (JOB_CONTROL)
  29. #include "nojobs.c"
  30. #else /* JOB_CONTROL */
  31.  
  32. #include "bashtypes.h"
  33. #include "trap.h"
  34. #include <stdio.h>
  35. #include <signal.h>
  36. #include <errno.h>
  37.  
  38. #if !defined (USG) || defined (HAVE_RESOURCE)
  39. #include <sys/time.h>
  40. #endif /* USG */
  41.  
  42. #if !defined (_POSIX_VERSION)
  43. #  if defined (HAVE_RESOURCE)
  44. #    include <sys/resource.h>
  45. #  endif
  46. #endif /* _POSIX_VERSION */
  47.  
  48. #include <sys/file.h>
  49. #include "filecntl.h"
  50. #include <sys/ioctl.h>
  51. #include <sys/param.h>
  52.  
  53. #if defined (BUFFERED_INPUT)
  54. #  include "input.h"
  55. #endif
  56.  
  57. /* Terminal handling stuff, to save and restore tty state. */
  58. #define NEW_TTY_DRIVER
  59.  
  60. /* Define this if your output is getting swallowed.  It's a no-op on
  61.    machines with the termio or termios tty drivers. */
  62. /* #define DRAIN_OUTPUT */
  63.  
  64. #if defined (_POSIX_VERSION) && !defined (TERMIOS_MISSING)
  65. #  undef NEW_TTY_DRIVER
  66. #  define TERMIOS_TTY_DRIVER
  67. #  if defined (sun) && !defined (_POSIX_SOURCE)    /* XXX - SunOS4, SunOS5? */
  68. #    define _POSIX_SOURCE
  69. #  endif
  70. #else /* !_POSIX_VERSION */
  71. #  if defined (USG) || defined (hpux) || defined (Xenix) || defined (sgi)
  72. #    undef NEW_TTY_DRIVER
  73. #    define TERMIO_TTY_DRIVER
  74. #  endif /* USG | hpux | Xenix | sgi */
  75. #endif /* !_POSIX_VERSION */
  76.  
  77. /* Include the right header file for the specific type of terminal
  78.    handler installed on this system. */
  79. #if defined (NEW_TTY_DRIVER)
  80. #include <sgtty.h>
  81. #endif
  82.  
  83. #if defined (TERMIO_TTY_DRIVER)
  84. #include <termio.h>
  85. #endif
  86.  
  87. #if defined (TERMIOS_TTY_DRIVER)
  88. /* For Sun workstations we undefine a couple of defines so that
  89.    the inclusion of termios.h won't cause complaints. */
  90. #  if defined (SunOS4)
  91. #    undef ECHO
  92. #    undef NOFLSH
  93. #    undef TOSTOP
  94. #  endif /* SunOS4 */
  95. #  include <termios.h>
  96. #endif /* TERMIOS_TTY_DRIVER */
  97.  
  98. /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
  99.  
  100. #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
  101. #  include <bsdtty.h>
  102. #endif /* hpux && !TERMIOS_TTY_DRIVER */
  103.  
  104. #include "bashansi.h"
  105. #include "shell.h"
  106. #include "jobs.h"
  107.  
  108. #include "builtins/builtext.h"
  109. #include "builtins/common.h"
  110.  
  111. /* Not all systems declare errno in errno.h... and some systems #define it! */
  112. #if !defined (errno)
  113. extern int errno;
  114. #endif /* !errno */
  115.  
  116. /* Variables used here but defined in other files. */
  117. extern int interactive, interactive_shell, asynchronous_notification;
  118. extern int subshell_environment;
  119. extern int posixly_correct, no_symbolic_links, shell_level;
  120. extern int interrupt_immediately, last_command_exit_value;
  121. extern int loop_level, breaking;
  122. extern Function *this_shell_builtin;
  123. extern char *shell_name, *this_command_name;
  124. extern sigset_t top_level_mask;
  125.  
  126. /* The array of known jobs. */
  127. JOB **jobs = (JOB **)NULL;
  128.  
  129. /* The number of slots currently allocated to JOBS. */
  130. int job_slots = 0;
  131.  
  132. /* The number of additional slots to allocate when we run out. */
  133. #define JOB_SLOTS 5
  134.  
  135. /* The controlling tty for this shell. */
  136. int shell_tty = -1;
  137.  
  138. /* The shell's process group. */
  139. pid_t shell_pgrp = NO_PID;
  140.  
  141. /* The terminal's process group. */
  142. pid_t terminal_pgrp = NO_PID;
  143.  
  144. /* The process group of the shell's parent. */
  145. pid_t original_pgrp = NO_PID;
  146.  
  147. /* The process group of the pipeline currently being made. */
  148. pid_t pipeline_pgrp = (pid_t)0;
  149.  
  150. #if defined (PGRP_PIPE)
  151. /* Pipes which each shell uses to communicate with the process group leader
  152.    until all of the processes in a pipeline have been started.  Then the
  153.    process leader is allowed to continue. */
  154. int pgrp_pipe[2] = { -1, -1 };
  155. #endif
  156.       
  157. /* The job which is current; i.e. the one that `%+' stands for. */
  158. int current_job = NO_JOB;
  159.  
  160. /* The previous job; i.e. the one that `%-' stands for. */
  161. int previous_job = NO_JOB;
  162.  
  163. /* Last child made by the shell.  */
  164. pid_t last_made_pid = NO_PID;
  165.  
  166. /* Pid of the last asynchronous child. */
  167. pid_t last_asynchronous_pid = NO_PID;
  168.  
  169. /* The pipeline currently being built. */
  170. PROCESS *the_pipeline = (PROCESS *)NULL;
  171.  
  172. /* If this is non-zero, do job control. */
  173. int job_control = 1;
  174.  
  175. /* Call this when you start making children. */
  176. int already_making_children = 0;
  177.  
  178. /* Functions local to this file. */
  179. static sighandler flush_child ();
  180. static PROCESS *find_pipeline ();
  181. static char *current_working_directory ();
  182. static char *job_working_directory ();
  183. static pid_t last_pid ();
  184. static int set_new_line_discipline (), map_over_jobs (), last_running_job ();
  185. static int most_recent_job_in_state (), last_stopped_job (), find_job ();
  186. static void notify_of_job_status (), cleanup_dead_jobs (), discard_pipeline ();
  187. static void add_process (), set_current_job (), reset_current ();
  188. static void pretty_print_job ();
  189. static void mark_dead_jobs_as_notified ();
  190. #if defined (PGRP_PIPE)
  191. static void pipe_read (), pipe_close ();
  192. #endif
  193.  
  194. /* Set this to non-zero whenever you don't want the jobs list to change at
  195.    all: no jobs deleted and no status change notifications.  This is used,
  196.    for example, when executing SIGCHLD traps, which may run arbitrary
  197.    commands. */
  198. static int freeze_jobs_list;
  199.  
  200. #if !defined (_POSIX_VERSION)
  201.  
  202. /* These are definitions to map POSIX 1003.1 functions onto existing BSD
  203.    library functions and system calls. */
  204. #define setpgid(pid, pgrp)    setpgrp (pid, pgrp)
  205. #define tcsetpgrp(fd, pgrp)    ioctl ((fd), TIOCSPGRP, &(pgrp))
  206.  
  207. pid_t
  208. tcgetpgrp (fd)
  209.      int fd;
  210. {
  211.   pid_t pgrp;
  212.  
  213.   /* ioctl will handle setting errno correctly. */
  214.   if (ioctl (fd, TIOCGPGRP, &pgrp) < 0)
  215.     return (-1);
  216.   return (pgrp);
  217. }
  218.  
  219. /* Perform OPERATION on NEWSET, perhaps leaving information in OLDSET. */
  220. sigprocmask (operation, newset, oldset)
  221.      int operation, *newset, *oldset;
  222. {
  223.   int old, new;
  224.  
  225.   if (newset)
  226.     new = *newset;
  227.   else
  228.     new = 0;
  229.  
  230.   switch (operation)
  231.     {
  232.     case SIG_BLOCK:
  233.       old = sigblock (new);
  234.       break;
  235.  
  236.     case SIG_SETMASK:
  237.       sigsetmask (new);
  238.       break;
  239.  
  240.     default:
  241.       internal_error ("Bad code in jobs.c: sigprocmask");
  242.     }
  243.  
  244.   if (oldset)
  245.     *oldset = old;
  246. }
  247. #endif /* !_POSIX_VERSION */
  248.  
  249. /* Return the working directory for the current process.  Unlike
  250.    job_working_directory, this does not call malloc (), nor do any
  251.    of the functions it calls.  This is so that it can safely be called
  252.    from a signal handler. */
  253. static char *
  254. current_working_directory ()
  255. {
  256.   char *dir;
  257.   static char d[MAXPATHLEN];
  258.  
  259.   dir = get_string_value ("PWD");
  260.  
  261.   if (!dir && the_current_working_directory && no_symbolic_links)
  262.     dir = the_current_working_directory;
  263.  
  264.   if (!dir)
  265.     {
  266.       dir = getwd (d);
  267.       if (dir)
  268.     dir = d;
  269.     }
  270.  
  271.   if (!dir)
  272.     return ("<unknown>");
  273.   else
  274.     return (dir);
  275. }
  276.  
  277. /* Return the working directory for the current process. */
  278. static char *
  279. job_working_directory ()
  280. {
  281.   char *dir;
  282.  
  283.   dir = get_string_value ("PWD");
  284.   if (dir)
  285.     return (savestring (dir));
  286.  
  287.   dir = get_working_directory ("job-working-directory");
  288.   if (dir)
  289.     return (dir);
  290.  
  291.   return (savestring ("<unknown>"));
  292. }
  293.  
  294. void
  295. making_children ()
  296. {
  297.   if (already_making_children)
  298.     return;
  299.  
  300.   already_making_children = 1;
  301.   start_pipeline ();
  302. }
  303.  
  304. void
  305. stop_making_children ()
  306. {
  307.   already_making_children = 0;
  308. }
  309.  
  310. /* Start building a pipeline.  */
  311. void
  312. start_pipeline ()
  313. {
  314.   if (the_pipeline)
  315.     {
  316.       discard_pipeline (the_pipeline);
  317.       the_pipeline = (PROCESS *)NULL;
  318.       pipeline_pgrp = 0;
  319. #if defined (PGRP_PIPE)
  320.       pipe_close (pgrp_pipe);
  321. #endif
  322.     }
  323.  
  324. #if defined (PGRP_PIPE)
  325.   if (job_control)
  326.     {
  327.       if (pipe (pgrp_pipe) == -1)
  328.     internal_error ("start_pipeline: pgrp pipe");
  329.     }
  330. #endif
  331. }
  332.  
  333. /* Stop building a pipeline.  Install the process list in the job array.
  334.    This returns the index of the newly installed job.
  335.    DEFERRED is a command structure to be executed upon satisfactory
  336.    execution exit of this pipeline. */
  337. int
  338. stop_pipeline (async, deferred)
  339.      int async;
  340.      COMMAND *deferred;
  341. {
  342.   register int i, j;
  343.   JOB *newjob = (JOB *)NULL;
  344.   sigset_t set, oset;
  345.  
  346.   BLOCK_CHILD (set, oset);
  347.  
  348. #if defined (PGRP_PIPE)
  349.   /* The parent closes the process group synchronization pipe. */
  350.   pipe_close (pgrp_pipe);
  351. #endif
  352.     
  353.   cleanup_dead_jobs ();
  354.  
  355.   if (!job_slots)
  356.     {
  357.       jobs =
  358.     (JOB **)xmalloc ((job_slots = JOB_SLOTS) * sizeof (JOB *));
  359.  
  360.       /* Now blank out these new entries. */
  361.       for (i = 0; i < job_slots; i++)
  362.     jobs[i] = (JOB *)NULL;
  363.     }
  364.  
  365.   /* Scan from the last slot backward, looking for the next free one. */
  366.   if (interactive)
  367.     {
  368.       for (i = job_slots; i; i--)
  369.     if (jobs[i - 1])
  370.       break;
  371.     }
  372.   else
  373.     {
  374.       /* If we're not interactive, we don't need to monotonically increase
  375.      the job number (in fact, we don't care about the job number at all),
  376.      so we can simply scan for the first free slot.  This helps to keep
  377.      us from continuously reallocating the jobs array when running
  378.      certain kinds of shell loops, and saves time spent searching. */
  379.       for (i = 0; i < job_slots; i++)
  380.     if (!jobs[i])
  381.       break;
  382.     }
  383.  
  384.   /* Do we need more room? */
  385.   if (i == job_slots)
  386.     {
  387.       job_slots += JOB_SLOTS;
  388.       jobs = (JOB **)xrealloc (jobs, ((1 + job_slots) * sizeof (JOB *)));
  389.  
  390.       for (j = i; j < job_slots; j++)
  391.     jobs[j] = (JOB *)NULL;
  392.     }
  393.  
  394.   /* Add the current pipeline to the job list. */
  395.   if (the_pipeline)
  396.     {
  397.       register PROCESS *p;
  398.  
  399.       newjob = (JOB *)xmalloc (sizeof (JOB));
  400.  
  401.       for (p = the_pipeline; p->next != the_pipeline; p = p->next);
  402.       p->next = (PROCESS *)NULL;
  403.       newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *);
  404.       for (p = newjob->pipe; p->next; p = p->next);
  405.       p->next = newjob->pipe;
  406.  
  407.       the_pipeline = (PROCESS *)NULL;
  408.       newjob->pgrp = pipeline_pgrp;
  409.       pipeline_pgrp = 0;
  410.  
  411.       newjob->flags = 0;
  412.  
  413.       /* Flag to see if in another pgrp. */
  414.       if (job_control)
  415.     newjob->flags |= J_JOBCONTROL;
  416.  
  417.       /* Set the state of this pipeline. */
  418.       {
  419.     register PROCESS *p = newjob->pipe;
  420.     register int any_alive = 0;
  421.     register int any_stopped = 0;
  422.  
  423.     do
  424.       {
  425.         any_alive |= p->running;
  426.         any_stopped |= WIFSTOPPED (p->status);
  427.         p = p->next;
  428.       }
  429.     while (p != newjob->pipe);
  430.  
  431.     if (any_alive)
  432.       {
  433.         newjob->state = JRUNNING;
  434.       }
  435.     else
  436.       {
  437.         if (any_stopped)
  438.           newjob->state = JSTOPPED;
  439.         else
  440.           newjob->state = JDEAD;
  441.       }
  442.       }
  443.  
  444.       newjob->wd = job_working_directory ();
  445.       newjob->deferred = deferred;
  446.  
  447.       jobs[i] = newjob;
  448.     }
  449.  
  450.   if (async)
  451.     {
  452.       if (newjob)
  453.     newjob->flags &= ~J_FOREGROUND;
  454.       reset_current ();
  455.     }
  456.   else
  457.     {
  458.       if (newjob)
  459.     {
  460.       newjob->flags |= J_FOREGROUND;
  461.       /*
  462.        *        !!!!! NOTE !!!!!  (chet@ins.cwru.edu)
  463.        *
  464.        * The currently-accepted job control wisdom says to set the
  465.        * terminal's process group n+1 times in an n-step pipeline:
  466.        * once in the parent and once in each child.  This is where
  467.        * the parent gives it away.
  468.        *
  469.        */
  470.       if (job_control && newjob->pgrp)
  471.         give_terminal_to (newjob->pgrp);
  472.     }
  473.     }
  474.  
  475.   stop_making_children ();
  476.   UNBLOCK_CHILD (oset);
  477.   return (current_job);
  478. }
  479.  
  480. /* Delete all DEAD jobs that the user had received notification about. */
  481. static void
  482. cleanup_dead_jobs ()
  483. {
  484.   register int i;
  485.   sigset_t set, oset;
  486.  
  487.   if (!job_slots || freeze_jobs_list)
  488.     return;
  489.  
  490.   BLOCK_CHILD (set, oset);
  491.  
  492.   for (i = 0; i < job_slots; i++)
  493.     if (jobs[i] && JOBSTATE (i) == JDEAD && (jobs[i]->flags & J_NOTIFIED))
  494.       delete_job (i);
  495.  
  496.   UNBLOCK_CHILD (oset);
  497. }
  498.  
  499. /* Delete the job at INDEX from the job list.  Must be called
  500.    with SIGCHLD blocked. */
  501. void
  502. delete_job (job_index)
  503.      int job_index;
  504. {
  505.   register JOB *temp;
  506.  
  507.   if (freeze_jobs_list)
  508.     return;
  509.  
  510.   temp = jobs[job_index];
  511.   if (job_index == current_job || job_index == previous_job)
  512.     reset_current ();
  513.  
  514.   jobs[job_index] = (JOB *)NULL;
  515.  
  516.   free (temp->wd);
  517.   discard_pipeline (temp->pipe);
  518.  
  519.   if (temp->deferred)
  520.     dispose_command (temp->deferred);
  521.  
  522.   free (temp);
  523. }
  524.  
  525. /* Get rid of the data structure associated with a process chain. */
  526. static void
  527. discard_pipeline (chain)
  528.      register PROCESS *chain;
  529. {
  530.   register PROCESS *this, *next;
  531.  
  532.   this = chain;
  533.   do
  534.     {
  535.       next = this->next;
  536.       if (this->command)
  537.     free (this->command);
  538.       free (this);
  539.       this = next;
  540.     }
  541.   while (this != chain);
  542. }
  543.  
  544. /* Add this process to the chain being built in the_pipeline.
  545.    NAME is the command string that will be exec'ed later.
  546.    PID is the process id of the child. */
  547. static void
  548. add_process (name, pid)
  549.      char *name;
  550.      pid_t pid;
  551. {
  552.   PROCESS *t = (PROCESS *)xmalloc (sizeof (PROCESS));
  553.  
  554.   t->next = the_pipeline;
  555.   t->pid = pid;
  556.   WSTATUS (t->status) = 0;
  557.   t->running = 1;
  558.   t->command = name;
  559.   the_pipeline = t;
  560.  
  561.   if (!(t->next))
  562.     t->next = t;
  563.   else
  564.     {
  565.       register PROCESS *p = t->next;
  566.  
  567.       while (p->next != t->next)
  568.     p = p->next;
  569.       p->next = t;
  570.     }
  571. }
  572.  
  573. #if 0
  574. /* Take the last job and make it the first job.  Must be called with
  575.    SIGCHLD blocked. */
  576. rotate_the_pipeline ()
  577. {
  578.   PROCESS *p;
  579.  
  580.   if (the_pipeline->next == the_pipeline)
  581.     return;
  582.   for (p = the_pipeline; p->next != the_pipeline; p = p->next)
  583.     ;
  584.   the_pipeline = p;
  585. }
  586.  
  587. /* Reverse the order of the processes in the_pipeline.  Must be called with
  588.    SIGCHLD blocked. */
  589. reverse_the_pipeline ()
  590. {
  591.   PROCESS *p, *n;
  592.  
  593.   if (the_pipeline->next == the_pipeline)
  594.     return;
  595.  
  596.   for (p = the_pipeline; p->next != the_pipeline; p = p->next)
  597.     ;
  598.   p->next = (PROCESS *)NULL;
  599.  
  600.   n = REVERSE_LIST (the_pipeline, PROCESS *);
  601.  
  602.   the_pipeline = n;
  603.   for (p = the_pipeline; p->next; p = p->next)
  604.     ;
  605.   p->next = the_pipeline;
  606. }
  607. #endif
  608.  
  609. /* Map FUNC over the list of jobs.  If FUNC returns non-zero,
  610.    then it is time to stop mapping, and that is the return value
  611.    for map_over_jobs.  FUNC is called with a JOB, arg1, arg2,
  612.    and INDEX. */
  613. static int
  614. map_over_jobs (func, arg1, arg2)
  615.      Function *func;
  616.      int arg1, arg2;
  617. {
  618.   register int i;
  619.   int result;
  620.   sigset_t set, oset;
  621.  
  622.   BLOCK_CHILD (set, oset);
  623.   result = 0;
  624.  
  625.   for (i = 0; i < job_slots; i++)
  626.     {
  627.       if (jobs[i])
  628.     {
  629.       result = (*func)(jobs[i], arg1, arg2, i);
  630.       if (result)
  631.         break;
  632.     }
  633.     }
  634.  
  635.   UNBLOCK_CHILD (oset);
  636.   return (result);
  637. }
  638.  
  639. /* Cause all the jobs in the current pipeline to exit. */
  640. void
  641. terminate_current_pipeline ()
  642. {
  643.   if (pipeline_pgrp && pipeline_pgrp != shell_pgrp)
  644.     {
  645.       killpg (pipeline_pgrp, SIGTERM);
  646.       killpg (pipeline_pgrp, SIGCONT);
  647.     }
  648. }
  649.  
  650. /* Cause all stopped jobs to exit. */
  651. void
  652. terminate_stopped_jobs ()
  653. {
  654.   register int i;
  655.  
  656.   for (i = 0; i < job_slots; i++)
  657.     {
  658.       if (jobs[i] && (JOBSTATE (i) == JSTOPPED))
  659.     {
  660.       killpg (jobs[i]->pgrp, SIGTERM);
  661.       killpg (jobs[i]->pgrp, SIGCONT);
  662.     }
  663.     }
  664. }
  665.  
  666. /* Cause all jobs, running or stopped, to receive a hangup signal. */
  667. void
  668. hangup_all_jobs ()
  669. {
  670.   register int i;
  671.  
  672.   for (i = 0; i < job_slots; i++)
  673.     {
  674.       if (jobs[i])
  675.     {
  676.       killpg (jobs[i]->pgrp, SIGHUP);
  677.       if (JOBSTATE (i) == JSTOPPED)
  678.         killpg (jobs[i]->pgrp, SIGCONT);
  679.     }
  680.     }
  681. }
  682.  
  683. void
  684. kill_current_pipeline ()
  685. {
  686.   stop_making_children ();
  687.   start_pipeline ();
  688. }
  689.  
  690. /* Return the pipeline that PID belongs to.  Note that the pipeline
  691.    doesn't have to belong to a job.  Must be called with SIGCHLD blocked. */
  692. static PROCESS *
  693. find_pipeline (pid)
  694.      pid_t pid;
  695. {
  696.   int job;
  697.  
  698.   /* See if this process is in the pipeline that we are building. */
  699.   if (the_pipeline)
  700.     {
  701.       register PROCESS *p = the_pipeline;
  702.  
  703.       do
  704.     {
  705.       /* Return it if we found it. */
  706.       if (p->pid == pid)
  707.         return (p);
  708.  
  709.       p = p->next;
  710.     }
  711.       while (p != the_pipeline);
  712.     }
  713.  
  714.   job = find_job (pid);
  715.  
  716.   if (job == NO_JOB)
  717.     return ((PROCESS *)NULL);
  718.   else
  719.     return (jobs[job]->pipe);
  720. }
  721.  
  722. /* Return the job index that PID belongs to, or NO_JOB if it doesn't
  723.    belong to any job.  Must be called with SIGCHLD blocked. */
  724. static int
  725. find_job (pid)
  726.      pid_t pid;
  727. {
  728.   register int i;
  729.   register PROCESS *p;
  730.  
  731.   for (i = 0; i < job_slots; i++)
  732.     {
  733.       if (jobs[i])
  734.     {
  735.       p = jobs[i]->pipe;
  736.  
  737.       do
  738.         {
  739.           if (p->pid == pid)
  740.         return (i);
  741.  
  742.           p = p->next;
  743.         }
  744.       while (p != jobs[i]->pipe);
  745.     }
  746.     }
  747.  
  748.   return (NO_JOB);
  749. }
  750.  
  751. /* Print descriptive information about the job with leader pid PID. */
  752. void
  753. describe_pid (pid)
  754.      pid_t pid;
  755. {
  756.   int job;
  757.   sigset_t set, oset;
  758.  
  759.   BLOCK_CHILD (set, oset);
  760.  
  761.   job = find_job (pid);
  762.  
  763.   if (job != NO_JOB)
  764.     printf ("[%d] %d\n", job + 1, pid);
  765.   else
  766.     programming_error ("describe_pid: No such pid (%d)!\n", pid);
  767.  
  768.   UNBLOCK_CHILD (oset);
  769. }
  770.  
  771. /* This is the way to print out information on a job if you
  772.    know the index.  FORMAT is:
  773.  
  774.     JLIST_NORMAL)   [1]+ Running       emacs
  775.     JLIST_LONG  )   [1]+ 2378 Running      emacs
  776.     -1      )   [1]+ 2378          emacs
  777.  
  778.     JLIST_NORMAL)   [1]+ Stopped       ls | more
  779.     JLIST_LONG  )   [1]+ 2369 Stopped      ls
  780.              2367        | more
  781.     JLIST_PID_ONLY)
  782.     Just list the pid of the process group leader (really
  783.     the process group).
  784.     JLIST_CHANGED_ONLY)
  785.     Use format JLIST_NORMAL, but list only jobs about which
  786.     the user has not been notified. */
  787. static void
  788. pretty_print_job (job_index, format, stream)
  789.      int job_index, format;
  790.      FILE *stream;
  791. {
  792.   register PROCESS *p, *first, *last;
  793.   int name_padding;
  794.   char retcode_name_buffer[20];
  795.   sigset_t set, oset;
  796.  
  797.   BLOCK_CHILD (set, oset);
  798.  
  799.   /* Format only pid information about the process group leader? */
  800.   if (format == JLIST_PID_ONLY)
  801.     {
  802.       fprintf (stream, "%d\n", jobs[job_index]->pipe->pid);
  803.       UNBLOCK_CHILD (oset);
  804.       return;
  805.     }
  806.  
  807.   if (format == JLIST_CHANGED_ONLY)
  808.     {
  809.       if (jobs[job_index]->flags & J_NOTIFIED)
  810.     {
  811.       UNBLOCK_CHILD (oset);
  812.       return;
  813.     }
  814.       format = JLIST_STANDARD;
  815.     }
  816.  
  817.   fprintf (stream, "[%d]%c ", job_index + 1,
  818.        (job_index == current_job) ? '+':
  819.        (job_index == previous_job) ? '-' : ' ');
  820.  
  821.   first = last = p = jobs[job_index]->pipe;
  822.   while (last->next != first)
  823.     last = last->next;
  824.  
  825.   /* We have printed information about this job.  When the job's
  826.      status changes, flush_child () sets the notification flag to 0. */
  827.   jobs[job_index]->flags |= J_NOTIFIED;
  828.  
  829.   for (;;)
  830.     {
  831.       if (p != first)
  832.     fprintf (stream, format ? "     " : " |");
  833.  
  834.       if (format)
  835.     fprintf (stream, "%5d", p->pid);
  836.  
  837.       fprintf (stream, " ");
  838.  
  839.       if (format > -1)
  840.     {
  841.       PROCESS *show = format ? p : last;
  842.       char *temp = "Done";
  843.  
  844.       if (JOBSTATE (job_index) == JSTOPPED && !format)
  845.         temp = "Stopped";
  846.  
  847.       if (JOBSTATE (job_index) == JRUNNING)
  848.         temp = "Running";
  849.       else
  850.         {
  851.           if (WIFSTOPPED (show->status))
  852.         temp = strsignal (WSTOPSIG (show->status));
  853.           else if (WIFSIGNALED (show->status))
  854.         temp = strsignal (WTERMSIG (show->status));
  855.           else if (WIFEXITED (show->status))
  856.         {
  857.           int exit_status;
  858.  
  859.           temp = retcode_name_buffer;
  860.           exit_status = WEXITSTATUS (show->status);
  861.  
  862.           if (!exit_status)
  863.             strcpy (temp, "Done");
  864.           else if (posixly_correct)
  865.             sprintf (temp, "Done(%d)", exit_status);
  866.           else
  867.             sprintf (temp, "Exit %d", exit_status);
  868.         }
  869.           else
  870.         temp = "Unknown status";
  871.         }
  872.  
  873.       if (p != first)
  874.         {
  875.           if (format)
  876.         {
  877.           if (show->running == first->running &&
  878.               WSTATUS (show->status) == WSTATUS (first->status))
  879.             temp = "";
  880.         }
  881.           else
  882.         temp = (char *)NULL;
  883.         }
  884.  
  885.       if (temp)
  886.         {
  887.           int templ = strlen (temp);
  888.           fprintf (stream, "%s", temp);
  889.  
  890.           if (templ)
  891.         name_padding = LONGEST_SIGNAL_DESC - templ;
  892.           else
  893.         name_padding = LONGEST_SIGNAL_DESC - 2; /* strlen ("| ") */
  894.  
  895.           fprintf (stream, "%*s", name_padding, "");
  896.  
  897.           if ((WIFSTOPPED (show->status) == 0) && (WIFCORED (show->status)))
  898.         fprintf (stream, "(core dumped) ");
  899.         }
  900.     }
  901.  
  902.       if (p != first && format)
  903.     fprintf (stream, "| ");
  904.  
  905.       if (p->command)
  906.     fprintf (stream, "%s", p->command);
  907.  
  908.       if (p == last) 
  909.     {
  910.       char *wd = current_working_directory ();
  911.  
  912.       if (JOBSTATE (job_index) == JRUNNING &&
  913.           !(jobs[job_index]->flags & J_FOREGROUND))
  914.         fprintf (stream, " &");
  915.  
  916.       if (strcmp (wd, jobs[job_index]->wd) != 0)
  917.         fprintf (stream,
  918.              "  (wd: %s)", polite_directory_format (jobs[job_index]->wd));
  919.     }
  920.  
  921.       if (format || (p == last))
  922.     fprintf (stream, "\r\n");
  923.  
  924.       if (p == last)
  925.     break;
  926.       p = p->next;
  927.     }
  928.  
  929.   fflush (stream);
  930.   UNBLOCK_CHILD (oset);
  931. }
  932.  
  933. int
  934. list_one_job (job, format, ignore, job_index)
  935.      JOB *job;
  936.      int format, ignore, job_index;
  937. {
  938.   pretty_print_job (job_index, format, stdout);
  939.   return (0);
  940. }
  941.  
  942. /* List jobs.  If FORMAT is non-zero, then the long form of the information
  943.    is printed, else just a short version. */
  944. void
  945. list_jobs (format)
  946.      int format;
  947. {
  948.   cleanup_dead_jobs ();
  949.   map_over_jobs (list_one_job, format, (int)IGNORE_ARG);
  950. }
  951.  
  952. /* Fork, handling errors.  Returns the pid of the newly made child, or 0.
  953.    COMMAND is just for remembering the name of the command; we don't do
  954.    anything else with it.  ASYNC_P says what to do with the tty.  If
  955.    non-zero, then don't give it away. */
  956. pid_t
  957. make_child (command, async_p)
  958.      char *command;
  959.      int async_p;
  960. {
  961.   sigset_t set, oset;
  962.   pid_t pid;
  963.  
  964.   sigemptyset (&set);
  965.   sigaddset (&set, SIGCHLD);
  966.   sigaddset (&set, SIGINT);
  967.   sigemptyset (&oset);
  968.   sigprocmask (SIG_BLOCK, &set, &oset);
  969.  
  970.   making_children ();
  971.  
  972. #if defined (BUFFERED_INPUT)
  973.   /* If default_buffered_input is active, we are reading a script.  If
  974.      the command is asynchronous, we have already duplicated /dev/null
  975.      as fd 0, but have not changed the buffered stream corresponding to
  976.      the old fd 0.  We don't want to sync the stream in this case. */
  977.   if (default_buffered_input != -1 &&
  978.       (!async_p || default_buffered_input > 0))
  979.     sync_buffered_stream (default_buffered_input);
  980. #endif /* BUFFERED_INPUT */
  981.  
  982.   /* Create the child, handle severe errors. */
  983.   if ((pid = fork ()) < 0)
  984.     {
  985.       internal_error ("fork: %s", strerror (errno));
  986.  
  987.       /* Kill all of the processes in the current pipeline. */
  988.       terminate_current_pipeline ();
  989.  
  990.       /* Discard the current pipeline, if any. */
  991.       if (the_pipeline)
  992.     kill_current_pipeline ();
  993.  
  994.       throw_to_top_level ();    /* Reset signals, etc. */
  995.     }
  996.  
  997.   if (pid == 0)
  998.     {
  999.       /* In the child.  Give this child the right process group, set the
  1000.      signals to the default state for a new process. */
  1001.       pid_t mine = getpid ();
  1002.  
  1003. #if defined (BUFFERED_INPUT)
  1004.       /* Close default_buffered_input if it's > 0.  We don't close it if it's
  1005.      0 because that's the file descriptor used when redirecting input,
  1006.      and it's wrong to close the file in that case. */
  1007.       if (default_buffered_input > 0)
  1008.     {
  1009.       close_buffered_fd (default_buffered_input);
  1010.       default_buffered_input = bash_input.location.buffered_fd = -1;
  1011.     }
  1012. #endif /* BUFFERED_INPUT */
  1013.  
  1014.       /* Restore top-level signal mask. */
  1015.       sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
  1016.  
  1017.       if (job_control)
  1018.     {
  1019.       /* All processes in this pipeline belong in the same
  1020.          process group. */
  1021.  
  1022.       if (!pipeline_pgrp)    /* Then this is the first child. */
  1023.         pipeline_pgrp = mine;
  1024.  
  1025.       /* Check for running command in backquotes. */
  1026.       if (pipeline_pgrp == shell_pgrp)
  1027.         {
  1028.           signal (SIGTSTP, SIG_IGN);
  1029.           signal (SIGTTOU, SIG_IGN);
  1030.           signal (SIGTTIN, SIG_IGN);
  1031.         }
  1032.       else
  1033.         {
  1034.           signal (SIGTSTP, SIG_DFL);
  1035.           signal (SIGTTOU, SIG_DFL);
  1036.           signal (SIGTTIN, SIG_DFL);
  1037.         }
  1038.  
  1039.       /* Set the process group before trying to mess with the terminal's
  1040.          process group.  This is mandated by POSIX. */
  1041.       /* This is in accordance with the Posix 1003.1 standard,
  1042.          section B.7.2.4, which says that trying to set the terminal
  1043.          process group with tcsetpgrp() to an unused pgrp value (like
  1044.          this would have for the first child) is an error.  Section
  1045.          B.4.3.3, p. 237 also covers this, in the context of job control
  1046.          shells. */
  1047.       if (setpgid (mine, pipeline_pgrp) < 0)
  1048.         internal_error ("child setpgid (%d to %d) error %d: %s\n",
  1049.                 mine, pipeline_pgrp, errno, strerror (errno));
  1050. #if defined (PGRP_PIPE)
  1051.       if (pipeline_pgrp == mine)
  1052.         {
  1053. #endif
  1054.           if (!async_p)
  1055.         give_terminal_to (pipeline_pgrp);
  1056.  
  1057. #if defined (PGRP_PIPE)
  1058.           pipe_read (pgrp_pipe);
  1059.         }
  1060. #endif
  1061.     }
  1062.       else            /* Without job control... */
  1063.     {
  1064.       if (!pipeline_pgrp)
  1065.         pipeline_pgrp = shell_pgrp;
  1066.  
  1067.       /* If these signals are set to SIG_DFL, we encounter the curious
  1068.          situation of an interactive ^Z to a running process *working*
  1069.          and stopping the process, but being unable to do anything with
  1070.          that process to change its state.  On the other hand, if they
  1071.          are set to SIG_IGN, jobs started from scripts do not stop when
  1072.          the shell running the script gets a SIGTSTP and stops. */
  1073.  
  1074.       signal (SIGTSTP, SIG_DFL);
  1075.       signal (SIGTTOU, SIG_DFL);
  1076.       signal (SIGTTIN, SIG_DFL);
  1077.     }
  1078.  
  1079. #if defined (PGRP_PIPE)
  1080.       /* Release the process group pipe, since our call to setpgid ()
  1081.      is done.  The last call to pipe_close is done in stop_pipeline. */
  1082.       pipe_close (pgrp_pipe);
  1083. #endif /* PGRP_PIPE */
  1084.  
  1085.       if (async_p)
  1086.     last_asynchronous_pid = getpid ();
  1087.     }
  1088.   else
  1089.     {
  1090.       /* In the parent.  Remember the pid of the child just created
  1091.      as the proper pgrp if this is the first child. */
  1092.  
  1093.       if (job_control)
  1094.     {
  1095.       if (!pipeline_pgrp)
  1096.         {
  1097.           pipeline_pgrp = pid;
  1098.           /* Don't twiddle terminal pgrps in the parent!  This is the bug,
  1099.          not the good thing of twiddling them in the child! */
  1100.           /* give_terminal_to (pipeline_pgrp); */
  1101.         }
  1102.       /* This is done on the recommendation of the Rationale section of
  1103.          the POSIX 1003.1 standard, where it discusses job control and
  1104.          shells.  It is done to avoid possible race conditions. (Ref.
  1105.          1003.1 Rationale, section B.4.3.3, page 236). */
  1106.       setpgid (pid, pipeline_pgrp);
  1107.     }
  1108.       else
  1109.     {
  1110.       if (!pipeline_pgrp)
  1111.         pipeline_pgrp = shell_pgrp;
  1112.     }
  1113.  
  1114.       /* Place all processes into the jobs array regardless of the
  1115.      state of job_control. */
  1116.       add_process (command, pid);
  1117.  
  1118.       if (async_p)
  1119.     last_asynchronous_pid = pid;
  1120.  
  1121.       last_made_pid = pid;
  1122.  
  1123.       /* Unblock SIGINT and SIGCHLD. */
  1124.       sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
  1125.     }
  1126.  
  1127.   return (pid);
  1128. }
  1129.  
  1130. /* When we end a job abnormally, or if we stop a job, we set the tty to the
  1131.    state kept in here.  When a job ends normally, we set the state in here
  1132.    to the state of the tty. */
  1133.  
  1134. #if defined (NEW_TTY_DRIVER)
  1135. static struct sgttyb shell_tty_info;
  1136. static struct tchars shell_tchars;
  1137. static struct ltchars shell_ltchars;
  1138. #endif /* NEW_TTY_DRIVER */
  1139.  
  1140. #if defined (TERMIO_TTY_DRIVER)
  1141. static struct termio shell_tty_info;
  1142. #endif /* TERMIO_TTY_DRIVER */
  1143.  
  1144. #if defined (TERMIOS_TTY_DRIVER)
  1145. static struct termios shell_tty_info;
  1146. #endif /* TERMIOS_TTY_DRIVER */
  1147.  
  1148. #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
  1149. /* Since the BSD tty driver does not allow us to change the tty modes
  1150.    while simultaneously waiting for output to drain and preserving
  1151.    typeahead, we have to drain the output ourselves before calling
  1152.    ioctl.  We cheat by finding the length of the output queue, and
  1153.    using select to wait for an appropriate length of time.  This is
  1154.    a hack, and should be labeled as such (it's a hastily-adapted
  1155.    mutation of a `usleep' implementation).  It's only reason for
  1156.    existing is the flaw in the BSD tty driver. */
  1157.  
  1158. static int ttspeeds[] =
  1159. {
  1160.   0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
  1161.   1800, 2400, 4800, 9600, 19200, 38400
  1162. };
  1163.  
  1164. static void
  1165. draino (fd, ospeed)
  1166.      int fd, ospeed;
  1167. {
  1168.   register int delay = ttspeeds[ospeed];
  1169.   int n;
  1170.  
  1171.   if (!delay)
  1172.     return;
  1173.  
  1174.   while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n)
  1175.     {
  1176.       if (n > (delay / 100))
  1177.     {
  1178.       struct timeval tv;
  1179.  
  1180.       n *= 10;        /* 2 bits more for conservativeness. */
  1181.       tv.tv_sec = n / delay;
  1182.       tv.tv_usec = ((n % delay) * 1000000) / delay;
  1183.       select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
  1184.     }
  1185.       else
  1186.     break;
  1187.     }
  1188. }
  1189. #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
  1190.  
  1191. /* Return the fd from which we are actually getting input. */
  1192. #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stdin)
  1193.  
  1194. /* Fill the contents of shell_tty_info with the current tty info. */
  1195. get_tty_state ()
  1196. {
  1197.   int tty = input_tty ();
  1198.  
  1199.   if (tty != -1)
  1200.     {
  1201. #if defined (NEW_TTY_DRIVER)
  1202.       ioctl (tty, TIOCGETP, &shell_tty_info);
  1203.       ioctl (tty, TIOCGETC, &shell_tchars);
  1204.       ioctl (tty, TIOCGLTC, &shell_ltchars);
  1205. #endif /* NEW_TTY_DRIVER */
  1206.  
  1207. #if defined (TERMIO_TTY_DRIVER)
  1208.       ioctl (tty, TCGETA, &shell_tty_info);
  1209. #endif /* TERMIO_TTY_DRIVER */
  1210.  
  1211. #if defined (TERMIOS_TTY_DRIVER)
  1212.       if (tcgetattr (tty, &shell_tty_info) < 0)
  1213.     {
  1214. #if 0
  1215.       /* Only print an error message if we're really interactive at
  1216.          this time. */
  1217.       if (interactive)
  1218.         internal_error ("[%d: %d] tcgetattr: %s",
  1219.                 getpid (), shell_level, strerror (errno));
  1220. #endif
  1221.       return -1;
  1222.     }
  1223. #endif /* TERMIOS_TTY_DRIVER */
  1224.     }
  1225.   return 0;
  1226. }
  1227.  
  1228. /* Make the current tty use the state in shell_tty_info. */
  1229. set_tty_state ()
  1230. {
  1231.   int tty = input_tty ();
  1232.  
  1233.   if (tty != -1)
  1234.     {
  1235. #if defined (NEW_TTY_DRIVER)
  1236. #  if defined (DRAIN_OUTPUT)
  1237.       draino (tty, shell_tty_info.sg_ospeed);
  1238. #  endif /* DRAIN_OUTPUT */
  1239.       ioctl (tty, TIOCSETN, &shell_tty_info);
  1240.       ioctl (tty, TIOCSETC, &shell_tchars);
  1241.       ioctl (tty, TIOCSLTC, &shell_ltchars);
  1242. #endif /* NEW_TTY_DRIVER */
  1243.  
  1244. #if defined (TERMIO_TTY_DRIVER)
  1245.       ioctl (tty, TCSETAW, &shell_tty_info);
  1246. #endif /* TERMIO_TTY_DRIVER */
  1247.  
  1248. #if defined (TERMIOS_TTY_DRIVER)
  1249.       if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
  1250.     {
  1251.       /* Only print an error message if we're really interactive at
  1252.          this time. */
  1253.       if (interactive)
  1254.         internal_error ("[%d: %d] tcsetattr: %s",
  1255.                 getpid (), shell_level, strerror (errno));
  1256.       return -1;
  1257.     }
  1258. #endif /* TERMIOS_TTY_DRIVER */
  1259.     }
  1260.   return 0;
  1261. }
  1262.  
  1263. /* Given an index into the jobs array JOB, return the pid of the last
  1264.    process in that job's pipeline.  This is the one whose exit status
  1265.    counts. */
  1266. static pid_t
  1267. last_pid (job)
  1268.      int job;
  1269. {
  1270.   register PROCESS *p;
  1271.   sigset_t set, oset;
  1272.  
  1273.   BLOCK_CHILD (set, oset);
  1274.  
  1275.   p = jobs[job]->pipe;
  1276.   while (p->next != jobs[job]->pipe)
  1277.     p = p->next;
  1278.  
  1279.   UNBLOCK_CHILD (oset);
  1280.   return (p->pid);
  1281. }
  1282.  
  1283. /* Wait for a particular child of the shell to finish executing.
  1284.    This low-level function prints an error message if PID is not
  1285.    a child of this shell.  It returns -1 if it fails, or 0 if not. */
  1286. int
  1287. wait_for_single_pid (pid)
  1288.      pid_t pid;
  1289. {
  1290.   register PROCESS *child;
  1291.  
  1292.   {
  1293.     sigset_t set, oset;
  1294.  
  1295.     BLOCK_CHILD (set, oset);
  1296.     child = find_pipeline (pid);
  1297.     UNBLOCK_CHILD (oset);
  1298.   }
  1299.  
  1300.   if (!child)
  1301.     {
  1302.       report_error ("wait: pid %d is not a child of this shell", pid);
  1303.       return (127);
  1304.     }
  1305.  
  1306.   return (wait_for (pid));
  1307. }
  1308.  
  1309. /* Wait for all of the backgrounds of this shell to finish. */
  1310. void
  1311. wait_for_background_pids ()
  1312. {
  1313.   while (1)
  1314.     {
  1315.       register int i, count = 0;
  1316.       sigset_t set, oset;
  1317.  
  1318.       BLOCK_CHILD (set, oset);
  1319.  
  1320.       for (i = 0; i < job_slots; i++)
  1321.     if (jobs[i] && (JOBSTATE (i) == JRUNNING) &&
  1322.         (jobs[i]->flags & J_FOREGROUND) == 0)
  1323.       {
  1324.         count++;
  1325.         break;
  1326.       }
  1327.  
  1328.       if (!count)
  1329.     {
  1330.       UNBLOCK_CHILD (oset);
  1331.       break;
  1332.     }
  1333.  
  1334.       for (i = 0; i < job_slots; i++)
  1335.     if (jobs[i] && (JOBSTATE (i) == JRUNNING) &&
  1336.         (jobs[i]->flags & J_FOREGROUND) == 0)
  1337.       {
  1338.         pid_t pid = last_pid (i);
  1339.         UNBLOCK_CHILD (oset);
  1340.         QUIT;
  1341.         wait_for_single_pid (pid);
  1342.         break;
  1343.       }
  1344.     }
  1345. }
  1346.  
  1347. /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
  1348. #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
  1349. static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER;
  1350.  
  1351. static void
  1352. restore_sigint_handler ()
  1353. {
  1354.   if (old_sigint_handler != INVALID_SIGNAL_HANDLER)
  1355.     {
  1356.       set_signal_handler (SIGINT, old_sigint_handler);
  1357.       old_sigint_handler = INVALID_SIGNAL_HANDLER;
  1358.     }
  1359. }
  1360.  
  1361. static int wait_sigint_received = 0;
  1362.  
  1363. /* Handle SIGINT while we are waiting for children in a script to exit.
  1364.    The `wait' builtin should be interruptible, but all others should be
  1365.    effectively ignored (i.e. not cause the shell to exit). */
  1366. static sighandler
  1367. wait_sigint_handler (sig)
  1368.      int sig;
  1369. {
  1370.   if (interrupt_immediately ||
  1371.       (this_shell_builtin && this_shell_builtin == wait_builtin))
  1372.     {
  1373.       last_command_exit_value = EXECUTION_FAILURE;
  1374.       restore_sigint_handler ();
  1375.       interrupt_state++;
  1376.       QUIT;
  1377.     }
  1378.  
  1379.   wait_sigint_received = 1;    /* XXX - should this be interrupt_state? */
  1380.   /* Otherwise effectively ignore the SIGINT and allow the running job to
  1381.      be killed. */
  1382. #if !defined (VOID_SIGHANDLER)
  1383.   return (0);
  1384. #endif /* !VOID_SIGHANDLER */
  1385. }
  1386.  
  1387. static int
  1388. process_exit_status (status)
  1389.      WAIT status;
  1390. {
  1391.   if (WIFSIGNALED (status))
  1392.     return (128 + WTERMSIG (status));
  1393.   else if (!WIFSTOPPED (status))
  1394.     return (WEXITSTATUS (status));
  1395.   else
  1396.     return (EXECUTION_SUCCESS);
  1397. }
  1398.  
  1399. /* Wait for pid (one of our children) to terminate, then
  1400.    return the termination state. */
  1401. int
  1402. wait_for (pid)
  1403.      pid_t pid;
  1404. {
  1405.   int job, termination_state;
  1406.   register PROCESS *child;
  1407.   sigset_t set, oset;
  1408.  
  1409.   /* In the case that this code is interrupted, and we longjmp () out of it,
  1410.      we are relying on the code in throw_to_top_level () to restore the
  1411.      top-level signal mask. */
  1412.   BLOCK_CHILD (set, oset);
  1413.  
  1414.   /* Ignore interrupts while waiting for a job run without job control
  1415.      to finish.  We don't want the shell to exit if an interrupt is
  1416.      received, only if one of the jobs run is killed via SIGINT.  If
  1417.      job control is not set, the job will be run in the same pgrp as 
  1418.      the shell, and the shell will see any signals the job gets. */
  1419.  
  1420.   /* This is possibly a race condition -- should it go in stop_pipeline? */
  1421.   wait_sigint_received = 0;
  1422.   if (!job_control)
  1423.     old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler);
  1424.  
  1425.   termination_state = last_command_exit_value;
  1426.  
  1427.   /* If we say wait_for (), then we have a record of this child somewhere.
  1428.      If this child and all of its peers are not running, then don't
  1429.      sigpause (), since there is no need to. */
  1430.  wait_loop:
  1431.  
  1432.   /* If the shell is interactive, and job control is disabled, see if the
  1433.      foreground process has died due to SIGINT and jump out of the wait
  1434.      loop if it has.  flush_child has already restored the old SIGINT
  1435.      signal handler. */
  1436.   if (interactive && !job_control)
  1437.     QUIT;
  1438.  
  1439.   child = find_pipeline (pid);
  1440.  
  1441.   if (!child)
  1442.     {
  1443.       give_terminal_to (shell_pgrp);
  1444.       UNBLOCK_CHILD (oset);
  1445.       programming_error ("wait_for: No record of pid %d", pid);
  1446.     }
  1447.  
  1448.   /* If this child is part of a job, then we are really waiting for the
  1449.      job to finish.  Otherwise, we are waiting for the child to finish. */
  1450.  
  1451.   job = find_job (pid);
  1452.  
  1453.   if (job != NO_JOB)
  1454.     {
  1455.       register int job_state = 0, any_stopped = 0;
  1456.       register PROCESS *p = jobs[job]->pipe;
  1457.  
  1458.       do
  1459.     {
  1460.       job_state |= p->running;
  1461.       if (!p->running)
  1462.         any_stopped |= WIFSTOPPED (p->status);
  1463.       p = p->next;
  1464.     }
  1465.       while (p != jobs[job]->pipe);
  1466.  
  1467.       if (job_state == 0)
  1468.     {
  1469.       if (any_stopped)
  1470.         jobs[job]->state = JSTOPPED;
  1471.       else
  1472.         jobs[job]->state = JDEAD;
  1473.     }
  1474.     }
  1475.  
  1476.   /* XXX - the linux people say to check for JOBSTATE (job) == JSTOPPED */
  1477.   if (child->running ||
  1478.       ((job != NO_JOB) && (JOBSTATE (job) == JRUNNING)))
  1479.     {
  1480. #if !defined (BROKEN_SIGSUSPEND)
  1481.       sigset_t suspend_set;
  1482.  
  1483.       sigemptyset (&suspend_set);
  1484.       sigsuspend (&suspend_set);
  1485. #else /* BROKEN_SIGSUSPEND */
  1486.       struct sigaction act, oact;
  1487.  
  1488.       act.sa_handler = SIG_DFL;
  1489.       sigemptyset (&act.sa_mask);
  1490.       act.sa_flags = 0;
  1491.  
  1492.       sigaction (SIGCHLD, &act, &oact);
  1493.       flush_child (0);
  1494.       sigaction (SIGCHLD, &oact, (struct sigaction *)NULL);
  1495. #endif /* BROKEN_SIGSUSPEND */
  1496.  
  1497.       goto wait_loop;
  1498.     }
  1499.  
  1500.   /* The exit state of the command is either the termination state of the
  1501.      child, or the termination state of the job.  If a job, the status
  1502.      of the last child in the pipeline is the significant one. */
  1503.  
  1504.   if (job != NO_JOB)
  1505.     {
  1506.       register PROCESS *p = jobs[job]->pipe;
  1507.  
  1508.       while (p->next != jobs[job]->pipe)
  1509.     p = p->next;
  1510.       termination_state = process_exit_status (p->status);
  1511.     }
  1512.   else
  1513.     termination_state = process_exit_status (child->status);
  1514.  
  1515.   if (job == NO_JOB || (jobs[job]->flags & J_JOBCONTROL))
  1516.     give_terminal_to (shell_pgrp);
  1517.  
  1518.   /* If the command did not exit cleanly, or the job is just
  1519.      being stopped, then reset the tty state back to what it
  1520.      was before this command.  Reset the tty state and notify
  1521.      the user of the job termination only if the shell is
  1522.      interactive.  Clean up any dead jobs in either case. */
  1523.   if (job != NO_JOB)
  1524.     {
  1525.       if (interactive_shell && !subshell_environment)
  1526.     {
  1527.       if (WIFSIGNALED (child->status) || WIFSTOPPED (child->status))
  1528.         set_tty_state ();
  1529.       else
  1530.         get_tty_state ();
  1531.  
  1532.       notify_and_cleanup ();
  1533.     }
  1534.       else
  1535.     {
  1536.       /* If this job is dead, and the shell is not interactive, make
  1537.          sure we turn on the notify bit so we don't get an unwanted
  1538.          message about the job's termination, and so delete_job really
  1539.          clears the slot in the jobs table. */
  1540.       if (JOBSTATE(job) == JDEAD)
  1541.         jobs[job]->flags |= J_NOTIFIED;
  1542.       cleanup_dead_jobs ();
  1543.     }
  1544.     }
  1545.     
  1546.   UNBLOCK_CHILD (oset);
  1547.  
  1548.   /* Restore the original SIGINT signal handler before we return. */
  1549.   restore_sigint_handler ();
  1550.  
  1551.   return (termination_state);
  1552. }
  1553.  
  1554. /* Wait for the last process in the pipeline for JOB. */
  1555. int
  1556. wait_for_job (job)
  1557.      int job;
  1558. {
  1559.   pid_t pid = last_pid (job);
  1560.   return (wait_for (pid));
  1561. }
  1562.  
  1563. /* Print info about dead jobs, and then delete them from the list
  1564.    of known jobs.  This does not actually delete jobs when the
  1565.    shell is not interactive, because the dead jobs are not marked
  1566.    as notified. */
  1567. void
  1568. notify_and_cleanup ()
  1569. {
  1570.   if (freeze_jobs_list)
  1571.     return;
  1572.  
  1573.   if (interactive)
  1574.     notify_of_job_status ();
  1575.  
  1576.   cleanup_dead_jobs ();
  1577. }
  1578.  
  1579. /* Make dead jobs disappear from the jobs array without notification.
  1580.    This is used when the shell is not interactive. */
  1581. void
  1582. reap_dead_jobs ()
  1583. {
  1584.   mark_dead_jobs_as_notified ();
  1585.   cleanup_dead_jobs ();
  1586. }
  1587.  
  1588. /* Return the next closest (chronologically) job to JOB which is in
  1589.    STATE.  STATE can be JSTOPPED, JRUNNING.  NO_JOB is returned if
  1590.    there is no next recent job. */
  1591. static int
  1592. most_recent_job_in_state (job, state)
  1593.      int job;
  1594.      JOB_STATE state;
  1595. {
  1596.   register int i, result;
  1597.   sigset_t set, oset;
  1598.  
  1599.   BLOCK_CHILD (set, oset);
  1600.   result = NO_JOB;
  1601.  
  1602.   for (i = job - 1; i >= 0; i--)
  1603.     {
  1604.       if (jobs[i])
  1605.     {
  1606.       if (JOBSTATE (i) == state)
  1607.         {
  1608.           result = i;
  1609.           break;
  1610.         }
  1611.     }
  1612.     }
  1613.   UNBLOCK_CHILD (oset);
  1614.   return (result);
  1615. }
  1616.  
  1617. /* Return the newest *stopped* job older than JOB, or NO_JOB if not
  1618.    found. */
  1619. static int
  1620. last_stopped_job (job)
  1621.      int job;
  1622. {
  1623.   return (most_recent_job_in_state (job, JSTOPPED));
  1624. }
  1625.  
  1626. /* Return the newest *running* job older than JOB, or NO_JOB if not
  1627.    found. */
  1628. static int
  1629. last_running_job (job)
  1630.      int job;
  1631. {
  1632.   return (most_recent_job_in_state (job, JRUNNING));
  1633. }
  1634.  
  1635. /* Make JOB be the current job, and make previous be useful.  Must be
  1636.    called with SIGCHLD blocked. */
  1637. static void
  1638. set_current_job (job)
  1639.      int job;
  1640. {
  1641.   int candidate = NO_JOB;
  1642.  
  1643.   if (current_job != job)
  1644.     {
  1645.       previous_job = current_job;
  1646.       current_job = job;
  1647.     }
  1648.  
  1649.   /* First choice for previous_job is the old current_job. */
  1650.   if (previous_job != current_job &&
  1651.       previous_job != NO_JOB &&
  1652.       jobs[previous_job] &&
  1653.       JOBSTATE (previous_job) == JSTOPPED)
  1654.     return;
  1655.  
  1656.   /* Second choice:  Newest stopped job that is older than
  1657.      the current job. */
  1658.   if (JOBSTATE (current_job) == JSTOPPED)
  1659.     {
  1660.       candidate = last_stopped_job (current_job);
  1661.  
  1662.       if (candidate != NO_JOB)
  1663.     {
  1664.       previous_job = candidate;
  1665.       return;
  1666.     }
  1667.     }
  1668.  
  1669.   /* If we get here, there is either only one stopped job, in which case it is
  1670.      the current job and the previous job should be set to the newest running
  1671.      job, or there are only running jobs and the previous job should be set to
  1672.      the newest running job older than the current job.  We decide on which
  1673.      alternative to use based on whether or not JOBSTATE(current_job) is
  1674.      JSTOPPED. */
  1675.  
  1676.   if (JOBSTATE (current_job) == JRUNNING)
  1677.     candidate = last_running_job (current_job);
  1678.   else
  1679.     candidate = last_running_job (job_slots);
  1680.  
  1681.   if (candidate != NO_JOB)
  1682.     {
  1683.       previous_job = candidate;
  1684.       return;
  1685.     }
  1686.  
  1687.   /* There is only a single job, and it is both `+' and `-'. */
  1688.   previous_job = current_job;
  1689. }
  1690.  
  1691. /* Make current_job be something useful, if it isn't already. */
  1692.  
  1693. /* Here's the deal:  The newest non-running job should be `+', and the
  1694.    next-newest non-running job should be `-'.  If there is only a single
  1695.    stopped job, the previous_job is the newest non-running job.  If there
  1696.    are only running jobs, the newest running job is `+' and the
  1697.    next-newest running job is `-'.  Must be called with SIGCHLD blocked. */
  1698. static void
  1699. reset_current ()
  1700. {
  1701.   int candidate = NO_JOB;
  1702.  
  1703.   if (current_job != NO_JOB &&
  1704.       job_slots && jobs[current_job] &&
  1705.       JOBSTATE (current_job) == JSTOPPED)
  1706.     {
  1707.       candidate = current_job;
  1708.     }
  1709.   else
  1710.     {
  1711.       /* First choice: the previous job! */
  1712.       if (previous_job != NO_JOB && jobs[previous_job] &&
  1713.       JOBSTATE (previous_job) == JSTOPPED)
  1714.     candidate = previous_job;
  1715.  
  1716.       /* Second choice: the most recently stopped job. */
  1717.       if (candidate == NO_JOB)
  1718.     candidate = last_stopped_job (job_slots);
  1719.  
  1720.       if (candidate == NO_JOB)
  1721.     {
  1722.       /* Third choice: the newest running job. */
  1723.       candidate = last_running_job (job_slots);
  1724.     }
  1725.     }
  1726.  
  1727.   /* If we found a job to use, then use it.  Otherwise, there
  1728.      are no jobs period. */
  1729.   if (candidate != NO_JOB)
  1730.     set_current_job (candidate);
  1731.   else
  1732.     current_job = previous_job = NO_JOB;
  1733. }
  1734.  
  1735. /* Start a job.  FOREGROUND if non-zero says to do that.  Otherwise,
  1736.    start the job in the background.  JOB is a zero-based index into
  1737.    JOBS.  Returns -1 if it is unable to start a job, and the return
  1738.    status of the job otherwise. */
  1739. int
  1740. start_job (job, foreground)
  1741.      int job, foreground;
  1742. {
  1743.   register PROCESS *p;
  1744.   int already_running;
  1745.   sigset_t set, oset;
  1746.   char *wd;
  1747. #if defined (NEW_TTY_DRIVER)
  1748.   static struct sgttyb save_stty;
  1749. #endif
  1750.  
  1751. #if defined (TERMIO_TTY_DRIVER)
  1752.   static struct termio save_stty;
  1753. #endif
  1754.  
  1755. #if defined (TERMIOS_TTY_DRIVER)
  1756.   static struct termios save_stty;
  1757. #endif
  1758.  
  1759.   BLOCK_CHILD (set, oset);
  1760.   already_running = (JOBSTATE (job) == JRUNNING);
  1761.  
  1762.   if (!foreground && already_running)
  1763.     {
  1764.       report_error ("%s: bg background job?", this_command_name);
  1765.       UNBLOCK_CHILD (oset);
  1766.       return (-1);
  1767.     }
  1768.  
  1769.   wd = current_working_directory ();
  1770.  
  1771.   /* You don't know about the state of this job.  Do you? */
  1772.   jobs[job]->flags &= ~J_NOTIFIED;
  1773.  
  1774.   if (foreground)
  1775.     {
  1776.       set_current_job (job);
  1777.       jobs[job]->flags |= J_FOREGROUND;
  1778.     }
  1779.  
  1780.   /* Tell the outside world what we're doing. */
  1781.   p = jobs[job]->pipe;
  1782.  
  1783.   if (!foreground)
  1784.     fprintf (stderr, "[%d]%c ", job + 1,
  1785.        (job == current_job) ? '+': ((job == previous_job) ? '-' : ' '));
  1786.  
  1787.   do
  1788.     {
  1789.       fprintf (stderr, "%s%s",
  1790.            p->command ? p->command : "",
  1791.            p->next != jobs[job]->pipe? " | " : "");
  1792.       p = p->next;
  1793.     }
  1794.   while (p != jobs[job]->pipe);
  1795.  
  1796.   if (!foreground)
  1797.     fprintf (stderr, " &");
  1798.  
  1799.   if (strcmp (wd, jobs[job]->wd) != 0)
  1800.     fprintf (stderr, "    (wd: %s)", polite_directory_format (jobs[job]->wd));
  1801.  
  1802.   fprintf (stderr, "\n");
  1803.  
  1804.   /* Run the job. */
  1805.   if (!already_running)
  1806.     {
  1807.       /* Each member of the pipeline is now running. */
  1808.       p = jobs[job]->pipe;
  1809.  
  1810.       do
  1811.     {
  1812.       if (WIFSTOPPED (p->status))
  1813.         p->running = 1;
  1814.       p = p->next;
  1815.     }
  1816.       while (p != jobs[job]->pipe);
  1817.  
  1818.       /* This means that the job is running. */
  1819.       JOBSTATE (job) = JRUNNING;
  1820.     }
  1821.  
  1822.   /* Save the tty settings before we start the job in the foreground. */
  1823.   if (foreground)
  1824.     {
  1825.       get_tty_state ();
  1826.       save_stty = shell_tty_info;
  1827.     }
  1828.  
  1829.   /* Give the terminal to this job. */
  1830.   if (foreground)
  1831.     {
  1832.       if (jobs[job]->flags & J_JOBCONTROL)
  1833.     give_terminal_to (jobs[job]->pgrp);
  1834.     }
  1835.   else
  1836.     jobs[job]->flags &= ~J_FOREGROUND;
  1837.  
  1838.   /* If the job is already running, then don't bother jump-starting it. */
  1839.   if (!already_running)
  1840.     {
  1841.       jobs[job]->flags |= J_NOTIFIED;
  1842.       killpg (jobs[job]->pgrp, SIGCONT);
  1843.     }
  1844.  
  1845.   UNBLOCK_CHILD (oset);
  1846.  
  1847.   if (foreground)
  1848.     {
  1849.       pid_t pid = last_pid (job);
  1850.       int s = wait_for (pid);
  1851.  
  1852.       shell_tty_info = save_stty;
  1853.       set_tty_state ();
  1854.       return (s);
  1855.     }
  1856.   else
  1857.     {
  1858.       BLOCK_CHILD (set, oset);
  1859.       reset_current ();
  1860.       UNBLOCK_CHILD (oset);
  1861.       return (0);
  1862.     }
  1863. }
  1864.  
  1865. /* Give PID SIGNAL.  This determines what job the pid belongs to (if any).
  1866.    If PID does belong to a job, and the job is stopped, then CONTinue the
  1867.    job after giving it SIGNAL.  Returns -1 on failure.  If GROUP is non-null,
  1868.    then kill the process group associated with PID. */
  1869. int
  1870. kill_pid (pid, sig, group)
  1871.      pid_t pid;
  1872.      int sig, group;
  1873. {
  1874.   register PROCESS *p;
  1875.   int job, result = EXECUTION_SUCCESS;
  1876.   sigset_t set, oset;
  1877.  
  1878.   BLOCK_CHILD (set, oset);
  1879.   p = find_pipeline (pid);
  1880.   job = find_job (pid);
  1881.  
  1882.   if (group)
  1883.     {
  1884.       if (job != NO_JOB)
  1885.     {
  1886.       jobs[job]->flags &= ~J_NOTIFIED;
  1887.  
  1888.       /* Kill process in backquotes or one started without job control? */
  1889.       if (jobs[job]->pgrp == shell_pgrp)
  1890.         {
  1891.           p = jobs[job]->pipe;
  1892.  
  1893.           do
  1894.         {
  1895.           kill (p->pid, sig);
  1896.           if (p->running == 0 && (sig == SIGTERM || sig == SIGHUP))
  1897.             kill (p->pid, SIGCONT);
  1898.           p = p->next;
  1899.         }
  1900.           while (p != jobs[job]->pipe);
  1901.         }
  1902.       else
  1903.         {
  1904.           result = killpg (jobs[job]->pgrp, sig);
  1905.           if (p && (JOBSTATE (job) == JSTOPPED) &&
  1906.           (sig == SIGTERM || sig == SIGHUP))
  1907.         killpg (jobs[job]->pgrp, SIGCONT);
  1908.         }
  1909.     }
  1910.       else
  1911.     result = killpg (pid, sig);
  1912.     }
  1913.   else
  1914.     result = kill (pid, sig);
  1915.  
  1916.   UNBLOCK_CHILD (oset);
  1917.   return (result);
  1918. }
  1919.  
  1920. /* Take care of system dependencies that must be handled when waiting for
  1921.    children.  The arguments to the WAITPID macro match those to the Posix.1
  1922.    waitpid() function. */
  1923.  
  1924. #if defined (Ultrix) && defined (mips) && defined (_POSIX_VERSION)
  1925. #  define WAITPID(pid, statusp, options) \
  1926.     wait3 ((union wait *)statusp, options, (struct rusage *)0)
  1927. #else
  1928. #  if defined (_POSIX_VERSION)
  1929. #    define WAITPID(pid, statusp, options) \
  1930.     waitpid ((pid_t)pid, statusp, options)
  1931. #  else
  1932. #    if defined (hpux)
  1933. #      define WAITPID(pid, statusp, options) \
  1934.     wait3 (statusp, options, (int *)0)
  1935. #    else
  1936. #      define WAITPID(pid, statusp, options) \
  1937.     wait3 (statusp, options, (struct rusage *)0)
  1938. #    endif /* !hpux */
  1939. #  endif /* !_POSIX_VERSION */
  1940. #endif /* !(Ultrix && mips && _POSIX_VERSION) */
  1941.  
  1942. /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
  1943.    handler for SIGCHLD. */
  1944.  
  1945. #if defined (hpux) && !defined (_POSIX_VERSION)
  1946. #  define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, flush_child)
  1947. #else
  1948. #  define REINSTALL_SIGCHLD_HANDLER
  1949. #endif /* !hpux || _POSIX_VERSION */
  1950.  
  1951. /* Flush_child () flushes at least one of the children that we are waiting for.
  1952.    It gets run when we have gotten a SIGCHLD signal, and stops when there
  1953.    aren't any children terminating any more.  If SIG is 0, this is to be a
  1954.    blocking wait for a single child.  It is here to get around SCO Unix's
  1955.    broken sigsuspend (). */
  1956. static sighandler
  1957. flush_child (sig)
  1958.      int sig;
  1959. {
  1960.   WAIT status;
  1961.   PROCESS *child;
  1962.   pid_t pid;
  1963.   int call_set_current = 0, last_stopped_job = NO_JOB;
  1964.   int children_exited = 0;
  1965.  
  1966.   do
  1967.     {
  1968.       pid = WAITPID (-1, &status, sig ? (WNOHANG | WUNTRACED) : WUNTRACED);
  1969.  
  1970.       if (pid > 0)
  1971.     {
  1972.       REINSTALL_SIGCHLD_HANDLER;
  1973.  
  1974.       /* Locate our PROCESS for this pid. */
  1975.       child = find_pipeline (pid);
  1976.  
  1977.       /* It is not an error to have a child terminate that we did
  1978.          not have a record of.  This child could have been part of
  1979.          a pipeline in backquote substitution. */
  1980.       if (child)
  1981.         {
  1982.           int job = find_job (pid);
  1983.  
  1984.           while (child->pid != pid)
  1985.         child = child->next;
  1986.  
  1987.           /* Remember status, and fact that process is not running. */
  1988.           child->status = status;
  1989.           child->running = 0;
  1990.  
  1991.           if (job != NO_JOB)
  1992.         {
  1993.           int job_state = 0;
  1994.           int any_stopped = 0;
  1995.  
  1996.           child = jobs[job]->pipe;
  1997.           jobs[job]->flags &= ~J_NOTIFIED;
  1998.  
  1999.           /* If all children are not running, but any of them is
  2000.              stopped, then the job is stopped, not dead. */
  2001.           do
  2002.            {
  2003.               job_state |= child->running;
  2004.               if (!child->running)
  2005.             any_stopped |= WIFSTOPPED (child->status);
  2006.               child = child->next;
  2007.             }
  2008.           while (child != jobs[job]->pipe);
  2009.  
  2010.           if (job_state == 0)
  2011.             {
  2012.               if (any_stopped)
  2013.             {
  2014.               jobs[job]->state = JSTOPPED;
  2015.               jobs[job]->flags &= ~J_FOREGROUND;
  2016.               call_set_current++;
  2017.               last_stopped_job = job;
  2018.               /* Suspending a job in a loop breaks out of all
  2019.                  active loops. */
  2020.               if (loop_level)
  2021.                 breaking = loop_level;
  2022.             }
  2023.               else
  2024.             {
  2025.               jobs[job]->state = JDEAD;
  2026.  
  2027.               if (job == last_stopped_job)
  2028.                 last_stopped_job = NO_JOB;
  2029.  
  2030.               /* If the foreground job is killed by SIGINT when
  2031.                  job control is not active, we need to perform
  2032.                  some special handling. */
  2033.               /* The check of wait_sigint_received is a way to
  2034.                  determine if the SIGINT came from the keyboard
  2035.                  (in which case the shell has already seen it,
  2036.                  and wait_sigint_received is non-zero, because
  2037.                  keyboard signals are sent to process groups)
  2038.                  or via kill(2) to the foreground process by
  2039.                  another process (or itself).  If the shell did
  2040.                  receive the SIGINT, it needs to perform normal
  2041.                  SIGINT processing. */
  2042.               if ((WTERMSIG (jobs[job]->pipe->status) == SIGINT) &&
  2043.                   (jobs[job]->flags & J_FOREGROUND) &&
  2044.                   (jobs[job]->flags & J_JOBCONTROL) == 0 &&
  2045.                   wait_sigint_received)
  2046.                 {
  2047.                   wait_sigint_received = 0;
  2048.  
  2049.                   /* If SIGINT is trapped, set the exit status so
  2050.                  that the trap handler can see it. */
  2051.                   if (signal_is_trapped (SIGINT))
  2052.                 last_command_exit_value = process_exit_status
  2053.                   (jobs[job]->pipe->status);
  2054.  
  2055.                   /* If the signal is trapped, let the trap handler
  2056.                  get it no matter what and simply return if
  2057.                  the trap handler returns.
  2058.                      maybe_call_trap_handler may cause dead jobs
  2059.                  to be removed from the job table because of
  2060.                  a call to execute_command.  Watch out for
  2061.                  this. */
  2062.                   if (maybe_call_trap_handler (SIGINT) == 0 &&
  2063.                       old_sigint_handler != INVALID_SIGNAL_HANDLER)
  2064.                 {
  2065.                   /* wait_sigint_handler () has already
  2066.                      seen SIGINT and allowed the wait
  2067.                      builtin to jump out.  We need to
  2068.                      call the original SIGINT handler. */
  2069.                   SigHandler *temp_handler;
  2070.                   temp_handler = old_sigint_handler;
  2071.                   restore_sigint_handler ();
  2072.                   (*temp_handler) (SIGINT);
  2073.                 }
  2074.                 }
  2075.             }
  2076.             }
  2077.         }
  2078.         }
  2079.       /* If we have caught a child, and a trap was set for SIGCHLD, then
  2080.          bump up the count of the number of children that have exited,
  2081.          so we know how many times to call it. */
  2082.       children_exited++;
  2083.     }
  2084.     }
  2085. #if defined (BROKEN_SIGSUSPEND)
  2086.   while (sig && pid > (pid_t)0);   /* Hack for SCO, see earlier comment. */
  2087. #else /* !BROKEN_SIGSUSPEND */
  2088.   while (pid > (pid_t)0);
  2089. #endif /* !BROKEN_SIGSUSPEND */
  2090.  
  2091.   /* If a job was running and became stopped, then set the current
  2092.      job.  Otherwise, don't change a thing. */
  2093.   if (call_set_current)
  2094.     if (last_stopped_job != NO_JOB)
  2095.       set_current_job (last_stopped_job);
  2096.     else
  2097.       reset_current ();
  2098.  
  2099.   /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
  2100.   if (job_control && signal_is_trapped (SIGCHLD) &&
  2101.       trap_list[SIGCHLD] != (char *)IGNORE_SIG)
  2102.     {
  2103.       char *trap_command;
  2104.  
  2105.       /* Turn off the trap list during the call to parse_and_execute ()
  2106.      to avoid potentially infinite recursive calls.  Preserve the
  2107.      values of last_command_exit_value, last_made_pid, and the_pipeline
  2108.      around the execution of the trap commands. */
  2109.       trap_command = savestring (trap_list[SIGCHLD]);
  2110.  
  2111.       begin_unwind_frame ("SIGCHLD trap");
  2112.       unwind_protect_int (last_command_exit_value);
  2113.       unwind_protect_int (last_made_pid);
  2114.       unwind_protect_int (interrupt_immediately);
  2115.       unwind_protect_int (freeze_jobs_list);
  2116.       unwind_protect_pointer (the_pipeline);
  2117.  
  2118.       /* We have to add the commands this way because they will be run
  2119.      in reverse order of adding.  We don't want maybe_set_sigchld_trap ()
  2120.      to reference freed memory. */
  2121.       add_unwind_protect ((Function *)xfree, trap_command);
  2122.       add_unwind_protect ((Function *)maybe_set_sigchld_trap, trap_command);
  2123.  
  2124.       the_pipeline = (PROCESS *)NULL;
  2125.       restore_default_signal (SIGCHLD);
  2126.       freeze_jobs_list = 1;
  2127.       while (children_exited--)
  2128.     {
  2129.       interrupt_immediately = 1;
  2130.       parse_and_execute (savestring (trap_command), "trap", -1);
  2131.     }
  2132.  
  2133.       run_unwind_frame ("SIGCHLD trap");
  2134.     }
  2135.  
  2136.   /* We have successfully recorded the useful information about this process
  2137.      that has just changed state.  If we notify asynchronously, and the job
  2138.      that this process belongs to is no longer running, then notify the user
  2139.      of that fact now. */
  2140.   if (asynchronous_notification && interactive)
  2141.     notify_of_job_status ();
  2142.  
  2143. #if !defined (VOID_SIGHANDLER)
  2144.   return (0);
  2145. #endif /* VOID_SIGHANDLER */
  2146. }
  2147.  
  2148. /* Function to call when you want to notify people of changes
  2149.    in job status.  This prints out all jobs which are pending
  2150.    notification to stderr, and marks those printed as already
  2151.    notified, thus making them candidates for cleanup. */
  2152. static void
  2153. notify_of_job_status ()
  2154. {
  2155.   register int job, termsig;
  2156.   char *dir;
  2157.   sigset_t set, oset;
  2158.  
  2159.   sigemptyset (&set);
  2160.   sigaddset (&set, SIGCHLD);
  2161.   sigaddset (&set, SIGTTOU);
  2162.   sigemptyset (&oset);
  2163.   sigprocmask (SIG_BLOCK, &set, &oset);
  2164.  
  2165.   dir = (char *)NULL;
  2166.  
  2167.   for (job = 0; job < job_slots; job++)
  2168.     {
  2169.       if (jobs[job] && (jobs[job]->flags & J_NOTIFIED) == 0)
  2170.     {
  2171.       WAIT s;
  2172.  
  2173.       s = jobs[job]->pipe->status;
  2174.       termsig = WTERMSIG (s);
  2175.  
  2176.       /* If job control is disabled, don't print the status messages.
  2177.          Mark dead jobs as notified so that they get cleaned up. */
  2178.       if (!job_control)
  2179.         {
  2180.           if (JOBSTATE (job) == JDEAD)
  2181.         jobs[job]->flags |= J_NOTIFIED;
  2182.           continue;
  2183.         }
  2184.  
  2185.       switch (JOBSTATE (job))
  2186.         {
  2187.           /* Print info on jobs that are running in the background,
  2188.          and on foreground jobs that were killed by anything
  2189.          except SIGINT. */
  2190.  
  2191.         case JDEAD:
  2192.  
  2193.           if (jobs[job]->flags & J_FOREGROUND)
  2194.         {
  2195.           if (termsig && WIFSIGNALED (s) && termsig != SIGINT)
  2196.             {
  2197.               fprintf (stderr, "%s", strsignal (termsig));
  2198.  
  2199.               if (WIFCORED (s))
  2200.             fprintf (stderr, " (core dumped)");
  2201.  
  2202.               fprintf (stderr, "\n");
  2203.             }
  2204.         }
  2205.           else
  2206.         {
  2207.           if (!dir)
  2208.             dir = current_working_directory ();
  2209.           pretty_print_job (job, 0, stderr);
  2210.           if (dir && strcmp (dir, jobs[job]->wd) != 0)
  2211.             fprintf (stderr,
  2212.                  "(wd now: %s)\n", polite_directory_format (dir));
  2213.         }
  2214.  
  2215.           jobs[job]->flags |= J_NOTIFIED;
  2216.           break;
  2217.  
  2218.         case JSTOPPED:
  2219.           fprintf (stderr, "\n");
  2220.           if (!dir)
  2221.         dir = current_working_directory ();
  2222.           pretty_print_job (job, 0, stderr);
  2223.           if (dir && (strcmp (dir, jobs[job]->wd) != 0))
  2224.         fprintf (stderr,
  2225.              "(wd now: %s)\n", polite_directory_format (dir));
  2226.           jobs[job]->flags |= J_NOTIFIED;
  2227.           break;
  2228.  
  2229.         case JRUNNING:
  2230.         case JMIXED:
  2231.           break;
  2232.  
  2233.         default:
  2234.           programming_error ("notify_of_job_status");
  2235.         }
  2236.     }
  2237.     }
  2238.   sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
  2239. }
  2240.  
  2241. /* getpgrp () varies between systems.  Even systems that claim to be
  2242.    Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
  2243. #if defined (_POSIX_VERSION) && !defined (BSD_GETPGRP)
  2244. #  define getpgid(p) getpgrp ()
  2245. #else
  2246. #  define getpgid(p) getpgrp (p)
  2247. #endif /* !_POSIX_VERSION || BSD_GETPGRP */
  2248.  
  2249. /* Initialize the job control mechanism, and set up the tty stuff. */
  2250. initialize_jobs ()
  2251. {
  2252.   shell_pgrp = getpgid (0);
  2253.  
  2254.   if (shell_pgrp == -1)
  2255.     {
  2256.       internal_error ("initialize_jobs: getpgrp failed: %s", strerror (errno));
  2257.       exit (1);
  2258.     }
  2259.  
  2260.   /* We can only have job control if we are interactive?
  2261.      I guess that makes sense. */
  2262.  
  2263.   if (!interactive)
  2264.     {
  2265.       job_control = 0;
  2266.       original_pgrp = NO_PID;
  2267.     }
  2268.   else
  2269.     {
  2270.       /* Make sure that we are using the new line discipline. */
  2271.  
  2272.       /* Get our controlling terminal.  If job_control is set, or
  2273.      interactive is set, then this is an interactive shell no
  2274.      matter what opening /dev/tty returns.  (It sometimes says
  2275.      the wrong thing.) */
  2276. #if !defined (NO_DEV_TTY_JOB_CONTROL)
  2277.       /* SCO Unix fails attempting job control on /dev/tty. */
  2278.       if ((shell_tty = open ("/dev/tty", O_RDWR, 0666)) < 0)
  2279. #endif /* !NO_DEV_TTY_JOB_CONTROL */
  2280.     shell_tty = dup (fileno (stdin));
  2281.  
  2282.       /* Find the highest unused file descriptor we can. */
  2283.       {
  2284.     int ignore, nds = getdtablesize ();
  2285.  
  2286.     if (nds <= 0)
  2287.       nds = 20;
  2288.     else if (nds > 256)
  2289.       nds = 256;
  2290.  
  2291.     while (--nds > 3)
  2292.       {
  2293.         if (fcntl (nds, F_GETFD, &ignore) == -1)
  2294.           break;
  2295.       }
  2296.  
  2297.     if (nds && shell_tty != nds && (dup2 (shell_tty, nds) != -1))
  2298.       {
  2299.         if (shell_tty != fileno (stdin))
  2300.           close (shell_tty);
  2301.         shell_tty = nds;
  2302.       }
  2303.       }
  2304.  
  2305. #if defined (RLOGIN_PGRP_BUG)
  2306.       /* Compensate for a bug in systems that compiled the BSD
  2307.      /usr/etc/rlogind with DEBUG defined, like NeXT and Alliant. */
  2308.       if (shell_pgrp == 0)
  2309.     {
  2310.       shell_pgrp = getpid ();
  2311.       setpgid (0, shell_pgrp);
  2312.       tcsetpgrp (shell_tty, shell_pgrp);
  2313.     }
  2314. #endif /* RLOGIN_PGRP_BUG */
  2315.  
  2316.       while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1)
  2317.     {
  2318.       if (shell_pgrp != terminal_pgrp)
  2319.         {
  2320.           SigHandler *old_ttin = (SigHandler *)signal (SIGTTIN, SIG_DFL);
  2321.           kill (0, SIGTTIN);
  2322.           signal (SIGTTIN, old_ttin);
  2323.           continue;
  2324.         }
  2325.       break;
  2326.     }
  2327.  
  2328.       if (set_new_line_discipline (shell_tty) < 0)
  2329.     {
  2330.       internal_error ("initialize_jobs: line discipline: %s",
  2331.               strerror (errno));
  2332.       job_control = 0;
  2333.     }
  2334.       else
  2335.     {
  2336.       original_pgrp = shell_pgrp;
  2337.       shell_pgrp = getpid ();
  2338.  
  2339.       if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0))
  2340.         {
  2341.           internal_error ("initialize_jobs: setpgid: %s", strerror (errno));
  2342.           shell_pgrp = original_pgrp;
  2343.         }
  2344.  
  2345.       job_control = 1;
  2346.       if (give_terminal_to (shell_pgrp) < 0)        /* XXX */
  2347.         /* job_control = 0 */;                /* XXX */
  2348.     }
  2349.       if (job_control == 0)
  2350.         internal_error ("no job control in this shell");    /* XXX */
  2351.     }
  2352.  
  2353.   if (shell_tty != fileno (stdin))
  2354.     SET_CLOSE_ON_EXEC (shell_tty);
  2355.  
  2356.   set_signal_handler (SIGCHLD, flush_child);
  2357.  
  2358.   change_flag ('m', job_control ? '-' : '+');
  2359.  
  2360.   if (interactive)
  2361.     get_tty_state ();
  2362.   return job_control;
  2363. }
  2364.  
  2365. /* Set the line discipline to the best this system has to offer.
  2366.    Return -1 if this is not possible. */
  2367. static int
  2368. set_new_line_discipline (tty)
  2369.      int tty;
  2370. {
  2371. #if defined (NEW_TTY_DRIVER)
  2372.   int ldisc;
  2373.  
  2374.   if (ioctl (tty, TIOCGETD, &ldisc) < 0)
  2375.     return (-1);
  2376.  
  2377.   if (ldisc != NTTYDISC)
  2378.     {
  2379.       ldisc = NTTYDISC;
  2380.  
  2381.       if (ioctl (tty, TIOCSETD, &ldisc) < 0)
  2382.     return (-1);
  2383.     }
  2384.   return (0);
  2385. #endif /* NEW_TTY_DRIVER */
  2386.  
  2387. #if defined (TERMIO_TTY_DRIVER)
  2388. #  if defined (NTTYDISC)
  2389.   if (ioctl (tty, TCGETA, &shell_tty_info) < 0)
  2390.     return (-1);
  2391.  
  2392.   if (shell_tty_info.c_line != NTTYDISC)
  2393.     {
  2394.       shell_tty_info.c_line = NTTYDISC;
  2395.       if (ioctl (tty, TCSETAW, &shell_tty_info) < 0)
  2396.     return (-1);
  2397.     }
  2398. #  endif /* NTTYDISC */
  2399.   return (0);
  2400. #endif /* TERMIO_TTY_DRIVER */
  2401.  
  2402. #if defined (TERMIOS_TTY_DRIVER)
  2403. #  if defined (TERMIOS_LDISC)
  2404.   if (tcgetattr (tty, &shell_tty_info) < 0)
  2405.     return (-1);
  2406.  
  2407.   if (shell_tty_info.c_line != NTTYDISC)
  2408.     {
  2409.       shell_tty_info.c_line = NTTYDISC;
  2410.       if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
  2411.     return (-1);
  2412.     }
  2413. #  endif /* TERMIOS_LDISC */
  2414.   return (0);
  2415. #endif /* TERMIOS_TTY_DRIVER */
  2416.  
  2417. #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
  2418.   return (-1);
  2419. #endif
  2420. }
  2421.  
  2422. static SigHandler *old_tstp, *old_ttou, *old_ttin;
  2423. static SigHandler *old_cont = (SigHandler *)SIG_DFL;
  2424. static sighandler stop_signal_handler (), cont_signal_handler ();
  2425.  
  2426. #if !defined (READLINE) && defined (TIOCGWINSZ) && defined (SIGWINCH)
  2427. static SigHandler *old_winch;
  2428.  
  2429. static sighandler
  2430. sigwinch_sighandler (sig)
  2431.      int sig;
  2432. {
  2433.   struct winsize win;
  2434.  
  2435. #if defined (USG) && !defined (_POSIX_VERSION)
  2436.   set_signal_handler (SIGWINCH, sigwinch_sighandler);
  2437. #endif /* USG && !_POSIX_VERSION */
  2438.   if ((ioctl (shell_tty, TIOCGWINSZ, &win) == 0) &&
  2439.       win.ws_row > 0 && win.ws_col > 0)
  2440.     {
  2441. #if defined (aixpc)
  2442.       shell_tty_info.c_winsize = win;    /* structure copying */
  2443. #endif
  2444.       set_lines_and_columns (win.ws_row, win.ws_col);
  2445.     }
  2446. }
  2447. #endif /* !READLINE && TIOCGWINSZ && SIGWINCH */
  2448.  
  2449. /* Setup this shell to handle C-C, etc. */
  2450. void
  2451. initialize_job_signals ()
  2452. {
  2453.   if (interactive)
  2454.     {
  2455.       set_signal_handler (SIGINT, sigint_sighandler);
  2456.       set_signal_handler (SIGTSTP, SIG_IGN);
  2457.       set_signal_handler (SIGTTOU, SIG_IGN);
  2458.       set_signal_handler (SIGTTIN, SIG_IGN);
  2459. #if !defined (READLINE) && defined (TIOCGWINSZ) && defined (SIGWINCH)
  2460.       old_winch = set_signal_handler (SIGWINCH, sigwinch_sighandler);
  2461. #endif /* !READLINE && TIOCGWINSZ && SIGWINCH */
  2462.     }
  2463.   else if (job_control)
  2464.     {
  2465.       old_tstp = set_signal_handler (SIGTSTP, stop_signal_handler);
  2466.       old_ttou = set_signal_handler (SIGTTOU, stop_signal_handler);
  2467.       old_ttin = set_signal_handler (SIGTTIN, stop_signal_handler);
  2468.     }
  2469.   /* Leave these things alone for non-interactive shells without job
  2470.      control. */
  2471. }
  2472.  
  2473. /* Here we handle CONT signals. */
  2474. static sighandler
  2475. cont_signal_handler (sig)
  2476.      int sig;
  2477. {
  2478.   initialize_job_signals ();
  2479.   set_signal_handler (SIGCONT, old_cont);
  2480.   kill (getpid (), SIGCONT);
  2481.  
  2482. #if !defined (VOID_SIGHANDLER)
  2483.   return (0);
  2484. #endif /* VOID_SIGHANDLER */
  2485. }
  2486.  
  2487. /* Here we handle stop signals while we are running not as a login shell. */
  2488. static sighandler
  2489. stop_signal_handler (sig)
  2490.      int sig;
  2491. {
  2492.   set_signal_handler (SIGTSTP, old_tstp);
  2493.   set_signal_handler (SIGTTOU, old_ttou);
  2494.   set_signal_handler (SIGTTIN, old_ttin);
  2495.  
  2496.   old_cont = set_signal_handler (SIGCONT, cont_signal_handler);
  2497.  
  2498.   give_terminal_to (shell_pgrp);
  2499.  
  2500.   kill (getpid (), sig);
  2501.  
  2502. #if !defined (VOID_SIGHANDLER)
  2503.   return (0);
  2504. #endif /* VOID_SIGHANDLER */
  2505. }
  2506.  
  2507. /* Give the terminal to PGRP.  */
  2508. give_terminal_to (pgrp)
  2509.      pid_t pgrp;
  2510. {
  2511.   sigset_t set, oset;
  2512.   int r = 0;
  2513.  
  2514.   if (job_control)
  2515.     {
  2516.       sigemptyset (&set);
  2517.       sigaddset (&set, SIGTTOU);
  2518.       sigaddset (&set, SIGTTIN);
  2519.       sigaddset (&set, SIGTSTP);
  2520.       sigaddset (&set, SIGCHLD);
  2521.       sigemptyset (&oset);
  2522.       sigprocmask (SIG_BLOCK, &set, &oset);
  2523.  
  2524.       if (tcsetpgrp (shell_tty, pgrp) < 0)
  2525.     {
  2526.       /* Maybe we should print an error message? */
  2527. /*      internal_error ("tcsetpgrp(%d) failed: pid %d to pgrp %d: %s",
  2528.         shell_tty, getpid(), pgrp, strerror (errno)); */
  2529.       r = -1;
  2530.     }
  2531.       else
  2532.     terminal_pgrp = pgrp;
  2533.  
  2534.       sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
  2535.     }
  2536.  
  2537.   return r;
  2538. }
  2539.  
  2540. /* Clear out any jobs in the job array.  This is intended to be used by
  2541.    children of the shell, who should not have any job structures as baggage
  2542.    when they start executing (forking subshells for parenthesized execution
  2543.    and functions with pipes are the two that spring to mind). */
  2544. static void
  2545. delete_all_jobs ()
  2546. {
  2547.   register int i;
  2548.   sigset_t set, oset;
  2549.  
  2550.   if (job_slots)
  2551.     {
  2552.       BLOCK_CHILD (set, oset);
  2553.  
  2554.       if (job_slots)
  2555.     {
  2556.       current_job = previous_job = NO_JOB;
  2557.  
  2558.       for (i = 0; i < job_slots; i++)
  2559.       if (jobs[i] != (JOB *) NULL)
  2560.         delete_job (i);
  2561.  
  2562.       free ((char *)jobs);
  2563.       job_slots = 0;
  2564.     }
  2565.  
  2566.       UNBLOCK_CHILD (oset);
  2567.     }
  2568. }
  2569.  
  2570. /* Mark all dead jobs as notified, so delete_job () cleans them out
  2571.    of the job table properly. */
  2572. static void
  2573. mark_dead_jobs_as_notified ()
  2574. {
  2575.   register int i;
  2576.   sigset_t set, oset;
  2577.  
  2578.   if (job_slots)
  2579.     {
  2580.       BLOCK_CHILD (set, oset);
  2581.  
  2582.       for (i = 0; i < job_slots; i++)
  2583.     if (jobs[i] && JOBSTATE (i) == JDEAD)
  2584.       jobs[i]->flags |= J_NOTIFIED;
  2585.  
  2586.       UNBLOCK_CHILD (oset);
  2587.     }
  2588. }
  2589.  
  2590. /* Allow or disallow job control to take place.  Returns the old value
  2591.    of job_control. */
  2592. int
  2593. set_job_control (arg)
  2594.      int arg;
  2595. {
  2596.   int old;
  2597.  
  2598.   old = job_control;
  2599.   job_control = arg;
  2600.   return (old);
  2601. }
  2602.  
  2603. /* Turn off all traces of job control.  This is run by children of the shell
  2604.    which are going to do shellsy things, like wait (), etc. */
  2605. void
  2606. without_job_control ()
  2607. {
  2608.   stop_making_children ();
  2609.   start_pipeline ();
  2610.   delete_all_jobs ();
  2611.   set_job_control (0);
  2612. }
  2613.  
  2614. /* If this shell is interactive, terminate all stopped jobs and
  2615.    restore the original terminal process group.  This is done
  2616.    before the `exec' builtin calls shell_execve. */
  2617. void
  2618. end_job_control ()
  2619. {
  2620.   if (interactive_shell)        /* XXX - should it be interactive? */
  2621.     {
  2622.       terminate_stopped_jobs ();
  2623.  
  2624.       if (original_pgrp >= 0)
  2625.     give_terminal_to (original_pgrp);
  2626.     }
  2627.  
  2628.   if (original_pgrp >= 0)
  2629.     setpgid (0, original_pgrp);
  2630. }
  2631.  
  2632. /* Restart job control by closing shell tty and reinitializing.  This is
  2633.    called after an exec fails in an interactive shell and we do not exit. */
  2634. void
  2635. restart_job_control ()
  2636. {
  2637.   if (shell_tty != -1)
  2638.     close (shell_tty);
  2639.   initialize_jobs ();
  2640. }
  2641.  
  2642. /* Set the handler to run when the shell receives a SIGCHLD signal. */
  2643. void
  2644. set_sigchld_handler ()
  2645. {
  2646.   set_signal_handler (SIGCHLD, flush_child);
  2647. }
  2648.  
  2649. #if defined (PGRP_PIPE)
  2650. /* Read from the read end of a pipe.  This is how the process group leader
  2651.    blocks until all of the processes in a pipeline have been made. */
  2652. static void
  2653. pipe_read (pp)
  2654.      int *pp;
  2655. {
  2656.   char ch;
  2657.  
  2658.   if (pp[1] >= 0)
  2659.     {
  2660.       close (pp[1]);
  2661.       pp[1] = -1;
  2662.     }
  2663.  
  2664.   if (pp[0] >= 0)
  2665.     {
  2666.       while (read (pp[0], &ch, 1) == -1 && errno == EINTR)
  2667.     continue;
  2668.     }
  2669. }
  2670.  
  2671. /* Close the read and write ends of PP, an array of file descriptors. */
  2672. static void
  2673. pipe_close (pp)
  2674.      int *pp;
  2675. {
  2676.   if (pp[0] >= 0)
  2677.     close (pp[0]);
  2678.  
  2679.   if (pp[1] >= 0)
  2680.     close (pp[1]);
  2681.  
  2682.   pp[0] = pp[1] = -1;
  2683. }
  2684.  
  2685. /* Functional interface closes our local-to-job-control pipes. */
  2686. close_pgrp_pipe ()
  2687. {
  2688.   pipe_close (pgrp_pipe);
  2689. }
  2690.  
  2691. #endif /* PGRP_PIPE */
  2692.  
  2693. #endif /* JOB_CONTROL */
  2694.